import { ref } from 'vue'
import mazeUtils from './useMaze'
export const useCats = () => {
    const cats = ref([]) // 猫咪列表
    const catCount = ref(3) // 猫咪数量

    // 获取猫咪移动对应的方向需要的计算坐标
    const moveDirection = () => {
        return {
            up: { row: -1,col: 0,name: 'up' },
            down: { row: 1,col: 0,name: 'down' },
            left: { row: 0,col: -1,name: 'left' },
            right: { row: 0,col: 1,name: 'right' }
         }
    }

    // 初始化猫咪生成猫咪的位置
    const initCats = () => {
        cats.value = []
        
        // 检查迷宫是否已经初始化
        if (!mazeUtils || !mazeUtils.maze || !mazeUtils.maze.value || mazeUtils.maze.value.length === 0) {
            console.warn('迷宫还未初始化，无法生成猫咪位置')
            return
        }
        
        // 使用迷宫工具生成多个不重复的有效位置
        const positions = mazeUtils.generateMultipleValidPositions(catCount.value)
      
        for (let i = 0; i < catCount.value; i++) {
            const position = positions[i] || { row: 0, col: 0 }
            
            const cat = {
                id: `cat-${i + 1}`,
                position: {
                    row: position.row,
                    col: position.col
                },
                // 使用精确的浮点数位置实现平滑移动
                exactPosition: {
                    x: position.col,
                    y: position.row
                },
                direction: 'right', // 初始方向
                speed: 0.05, // 每帧移动的格子数（速度）
                color: getRandomCatColor(i),
                lastMoveTime: Date.now(),
                isMoving: true, // 默认开始移动
                moveStartTime: 0,
                moveDuration: 300
            }
            
            cats.value.push(cat)
        }
        console.log('生成的猫咪位置:', cats.value)
    }

    // 给猫咪一个移动的方法
    const moveCat = (catId, direction) => {
        const cat = cats.value.find(cat => cat.id === catId)
        if (cat) {
            cat.position.row += direction.row
            cat.position.col += direction.col
        }
    }

    // 获取随机猫咪颜色
    const getRandomCatColor = (index) => {
        const colors = [
            '#FF6B6B', // 红色
            '#4ECDC4', // 青色
            '#45B7D1', // 蓝色
            '#96CEB4', // 绿色
            '#FFEAA7', // 黄色
            '#DDA0DD', // 紫色
            '#FFB347', // 橙色
            '#87CEEB'  // 天蓝色
        ]
        return colors[index % colors.length]
    }

    // 检查猫咪位置是否有效
    const validateCatPosition = (cat) => {
        return mazeUtils.isValidPosition(cat.position.row, cat.position.col)
    }

    // 重新定位猫咪到有效位置
    const repositionCat = (catId) => {
        const cat = cats.value.find(cat => cat.id === catId)
        if (cat) {
            const newPosition = mazeUtils.generateRandomValidPosition()
            cat.position.row = newPosition.row
            cat.position.col = newPosition.col
            cat.exactPosition.x = newPosition.col
            cat.exactPosition.y = newPosition.row
        }
    }

    // 获取猫咪的相邻有效移动方向
    const getValidMoveDirections = (cat, direction) => {
        return Object.values(moveDirection()).filter(dir => {
            const newRow = cat.position.row + dir.row
            const newCol = cat.position.col + dir.col
            let directionFlag = '' // 定义反方向
            // 如果存在direction，不能是反方向
            switch(direction) {
                case 'up':
                    directionFlag = 'down'
                    break
                case 'down':
                    directionFlag = 'up'
                    break
                case 'left':
                    directionFlag = 'right'
                    break
                case 'right':
                    directionFlag = 'left'
                    break
                default:
                    directionFlag = ''
                    break
            }

            return mazeUtils.isValidPosition(newRow, newCol) && directionFlag !== dir.name
        })
    }

    // 检查精确位置是否有效（用于碰撞检测）
    const isExactPositionValid = (exactX, exactY) => {
        const row = Math.floor(exactY) 
        const col = Math.floor(exactX) 
        // 判断是不是在迷宫的边界
        if(row < 0 || col < 0 || row >= mazeUtils.maze.value.length || col >= mazeUtils.maze.value[0].length){
            return false
        }
        return mazeUtils.isValidPosition(row, col)
    }

    // 更新猫咪的精确位置（连续移动）
    const updateCatExactPosition = (cat) => {
        if (!cat.isMoving) return

        const dir = moveDirection()[cat.direction]
        const newExactX = cat.exactPosition.x + dir.col * cat.speed
        const newExactY = cat.exactPosition.y + dir.row * cat.speed

        // 检查新位置是否有效
        if (isExactPositionValid(newExactX, newExactY)) {
            // 移动有效，更新位置
            cat.exactPosition.x = newExactX
            cat.exactPosition.y = newExactY
            
            // 更新逻辑位置（整数格子位置）
            cat.position.row = Math.floor(cat.exactPosition.y)
            cat.position.col = Math.floor(cat.exactPosition.x)
        } else {
            // 遇到障碍，改变方向
            const validDirections = getValidMoveDirections(cat, cat.direction)
            if (validDirections.length > 0) {
                cat.direction = validDirections[Math.floor(Math.random() * validDirections.length)].name
            } else {
                // 如果没有有效方向，停止移动
                cat.isMoving = false
            }
        }
    }

    // 设置猫咪移动方向的坐标计算（带动画）
    const setCatMoveDirection = (catId, direction) => {
        const cat = cats.value.find(cat => cat.id === catId)
        if (cat) {
            cat.direction = direction
            cat.isMoving = true
        }
    }

    // 获取猫咪的视觉位置（用于渲染）
    const getCatVisualPosition = (cat) => {
        return {
            x: cat.exactPosition.x * 50 + (50-40)/2,
            y: cat.exactPosition.y * 50 + (50-40)/2
        }
    }

    // 判断当前游戏迷宫是否有两只猫咪相遇
    const isCatsMeet = () => {
        return cats.value.some(cat => {
            return cats.value.some(otherCat => 
                otherCat.id !== cat.id && 
                Math.abs(cat.exactPosition.x - otherCat.exactPosition.x) < 0.5 &&
                Math.abs(cat.exactPosition.y - otherCat.exactPosition.y) < 0.5
            )
        })
    }

    return { 
        cats, 
        catCount, 
        initCats, 
        moveCat,
        validateCatPosition,
        repositionCat,
        getValidMoveDirections,
        setCatMoveDirection,
        updateCatExactPosition,
        getCatVisualPosition,
        isCatsMeet 
    }
}